<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="theme-color" content="#375EAB">
<title>Gosl &ndash; package utl</title>
<link type="text/css" rel="stylesheet" href="static/style.css">
<script type="text/javascript" src="static/godocs.js"></script>
<style type="text/css"></style>
</head>
<body>
<div id="page" class=\wide">
<div class="container">
<h1>Gosl &ndash; <b>utl</b> &ndash; Utilities. Lists. Dictionaries. Simple Numerics</h1>
use 'godoc cmd/github.com/cpmech/gosl/utl' for documentation on the github.com/cpmech/gosl/utl command 

<!--
	Copyright 2009 The Go Authors. All rights reserved.
	Use of this source code is governed by a BSD-style
	license that can be found in the LICENSE file.
-->
<!--
	Note: Static (i.e., not template-generated) href and id
	attributes start with "pkg-" to make it impossible for
	them to conflict with generated attributes (some of which
	correspond to Go identifiers).
-->

	<script type='text/javascript'>
	document.ANALYSIS_DATA = ;
	document.CALLGRAPH = ;
	</script>

	
		
		<div id="short-nav">
			<dl>
			<dd><code>import "github.com/cpmech/gosl/utl"</code></dd>
			</dl>
			<dl>
			<dd><a href="#pkg-overview" class="overviewLink">Overview</a></dd>
			<dd><a href="#pkg-index" class="indexLink">Index</a></dd>
			
			
				<dd><a href="#pkg-subdirectories">Subdirectories</a></dd>
			
			</dl>
		</div>
		<!-- The package's Name is printed as title by the top-level template -->
		<div id="pkg-overview" class="toggleVisible">
			<div class="collapsed">
				<h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
			</div>
			<div class="expanded">
				<h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
				<p>
package utl implements functions for simplifying calculations and allocation of structures
such as slices and slices of slices. It also contains functions for sorting quantities.
</p>

			</div>
		</div>
		

		<div id="pkg-index" class="toggleVisible">
		<div class="collapsed">
			<h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
		</div>
		<div class="expanded">
			<h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>

		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
			<div id="manual-nav">
			<dl>
			
				<dd><a href="#pkg-constants">Constants</a></dd>
			
			
			
				
				<dd><a href="#BestSquare">func BestSquare(size int) (nrow, ncol int)</a></dd>
			
				
				<dd><a href="#BoolAllFalse">func BoolAllFalse(values []bool) bool</a></dd>
			
				
				<dd><a href="#BoolAllTrue">func BoolAllTrue(values []bool) bool</a></dd>
			
				
				<dd><a href="#Cross3d">func Cross3d(w, u, v []float64)</a></dd>
			
				
				<dd><a href="#CumSum">func CumSum(cs, p []float64)</a></dd>
			
				
				<dd><a href="#Dbl2Str">func Dbl2Str(v []float64, format string) (s []string)</a></dd>
			
				
				<dd><a href="#DblArgMinMax">func DblArgMinMax(v []float64) (imin, imax int)</a></dd>
			
				
				<dd><a href="#DblArrayToMat">func DblArrayToMat(v []float64, m, n int) (a [][]float64)</a></dd>
			
				
				<dd><a href="#DblCopy">func DblCopy(in []float64) (out []float64)</a></dd>
			
				
				<dd><a href="#DblDsort3">func DblDsort3(a, b, c *float64)</a></dd>
			
				
				<dd><a href="#DblGetSorted">func DblGetSorted(A []float64) (Asorted []float64)</a></dd>
			
				
				<dd><a href="#DblMatToArray">func DblMatToArray(a [][]float64) (v []float64)</a></dd>
			
				
				<dd><a href="#DblMinMax">func DblMinMax(v []float64) (mi, ma float64)</a></dd>
			
				
				<dd><a href="#DblOnes">func DblOnes(n int) (res []float64)</a></dd>
			
				
				<dd><a href="#DblSort3">func DblSort3(a, b, c *float64)</a></dd>
			
				
				<dd><a href="#DblSort4">func DblSort4(a, b, c, d *float64)</a></dd>
			
				
				<dd><a href="#DblSplit">func DblSplit(s string) (r []float64)</a></dd>
			
				
				<dd><a href="#DblSum">func DblSum(v []float64) (sum float64)</a></dd>
			
				
				<dd><a href="#DblVals">func DblVals(n int, v float64) (res []float64)</a></dd>
			
				
				<dd><a href="#DblsAlloc">func DblsAlloc(m, n int) (mat [][]float64)</a></dd>
			
				
				<dd><a href="#DblsGetColumn">func DblsGetColumn(j int, v [][]float64) (x []float64)</a></dd>
			
				
				<dd><a href="#DblsParetoMin">func DblsParetoMin(u, v []float64) (u_dominates, v_dominates bool)</a></dd>
			
				
				<dd><a href="#DblsParetoMinProb">func DblsParetoMinProb(u, v []float64, φ float64) (u_dominates bool)</a></dd>
			
				
				<dd><a href="#Deep3Deserialize">func Deep3Deserialize(I, P []int, S []float64, debug bool) (A [][][]float64)</a></dd>
			
				
				<dd><a href="#Deep3GetInfo">func Deep3GetInfo(I, P []int, S []float64, verbose bool) (nitems, nrows, ncols_tot int, ncols []int)</a></dd>
			
				
				<dd><a href="#Deep3Serialize">func Deep3Serialize(A [][][]float64) (I, P []int, S []float64)</a></dd>
			
				
				<dd><a href="#Deep3alloc">func Deep3alloc(n1, n2, n3 int) (a [][][]float64)</a></dd>
			
				
				<dd><a href="#Deep3set">func Deep3set(a [][][]float64, v float64)</a></dd>
			
				
				<dd><a href="#Deep4alloc">func Deep4alloc(n1, n2, n3, n4 int) (a [][][][]float64)</a></dd>
			
				
				<dd><a href="#Deep4set">func Deep4set(a [][][][]float64, v float64)</a></dd>
			
				
				<dd><a href="#Digits">func Digits(maxint int) (ndigits int, format string)</a></dd>
			
				
				<dd><a href="#DoProf">func DoProf(silent bool, option int) func()</a></dd>
			
				
				<dd><a href="#Dot3d">func Dot3d(u, v []float64) (s float64)</a></dd>
			
				
				<dd><a href="#DurSum">func DurSum(v []time.Duration) (seconds float64)</a></dd>
			
				
				<dd><a href="#Expon">func Expon(val float64) (ndigits int)</a></dd>
			
				
				<dd><a href="#FlipCoin">func FlipCoin(p float64) bool</a></dd>
			
				
				<dd><a href="#GetITout">func GetITout(all_output_times, time_stations_out []float64, tol float64) (I []int, T []float64)</a></dd>
			
				
				<dd><a href="#GtPenalty">func GtPenalty(x, b, penaltyM float64) float64</a></dd>
			
				
				<dd><a href="#GtePenalty">func GtePenalty(x, b, penaltyM float64) float64</a></dd>
			
				
				<dd><a href="#Imax">func Imax(a, b int) int</a></dd>
			
				
				<dd><a href="#Imin">func Imin(a, b int) int</a></dd>
			
				
				<dd><a href="#IntAddScalar">func IntAddScalar(a []int, s int) (res []int)</a></dd>
			
				
				<dd><a href="#IntBoolMapSort">func IntBoolMapSort(m map[int]bool) (sorted_keys []int)</a></dd>
			
				
				<dd><a href="#IntFill">func IntFill(s []int, val int)</a></dd>
			
				
				<dd><a href="#IntFilter">func IntFilter(a []int, out func(idx int) bool) (res []int)</a></dd>
			
				
				<dd><a href="#IntIndexSmall">func IntIndexSmall(a []int, val int) int</a></dd>
			
				
				<dd><a href="#IntIndexSorted">func IntIndexSorted(a []int, val int, aSortedIn []int) (idx int, aSortedOut []int)</a></dd>
			
				
				<dd><a href="#IntIntsMapAppend">func IntIntsMapAppend(m *map[int][]int, key int, item int)</a></dd>
			
				
				<dd><a href="#IntMinMax">func IntMinMax(v []int) (mi, ma int)</a></dd>
			
				
				<dd><a href="#IntNegOut">func IntNegOut(a []int) (res []int)</a></dd>
			
				
				<dd><a href="#IntPy">func IntPy(a []int) (res string)</a></dd>
			
				
				<dd><a href="#IntRange">func IntRange(n int) (res []int)</a></dd>
			
				
				<dd><a href="#IntRange2">func IntRange2(start, stop int) []int</a></dd>
			
				
				<dd><a href="#IntRange3">func IntRange3(start, stop, step int) (res []int)</a></dd>
			
				
				<dd><a href="#IntSort3">func IntSort3(a, b, c *int)</a></dd>
			
				
				<dd><a href="#IntSort4">func IntSort4(a, b, c, d *int)</a></dd>
			
				
				<dd><a href="#IntUnique">func IntUnique(slices ...[]int) (res []int)</a></dd>
			
				
				<dd><a href="#IntVals">func IntVals(n int, val int) (s []int)</a></dd>
			
				
				<dd><a href="#IntsAlloc">func IntsAlloc(m, n int) (mat [][]int)</a></dd>
			
				
				<dd><a href="#IntsClone">func IntsClone(a [][]int) (b [][]int)</a></dd>
			
				
				<dd><a href="#L2norm">func L2norm(p, q []float64) (dist float64)</a></dd>
			
				
				<dd><a href="#LinSpace">func LinSpace(start, stop float64, num int) (res []float64)</a></dd>
			
				
				<dd><a href="#LinSpaceOpen">func LinSpaceOpen(start, stop float64, num int) (res []float64)</a></dd>
			
				
				<dd><a href="#Max">func Max(a, b float64) float64</a></dd>
			
				
				<dd><a href="#MeshGrid2D">func MeshGrid2D(xmin, xmax, ymin, ymax float64, nx, ny int) (x, y [][]float64)</a></dd>
			
				
				<dd><a href="#Min">func Min(a, b float64) float64</a></dd>
			
				
				<dd><a href="#ParetoFront">func ParetoFront(Ovs [][]float64) (front []int)</a></dd>
			
				
				<dd><a href="#PrintDeep3">func PrintDeep3(name string, A [][][]float64)</a></dd>
			
				
				<dd><a href="#PrintDeep4">func PrintDeep4(name string, A [][][][]float64, format string)</a></dd>
			
				
				<dd><a href="#PrintMemStat">func PrintMemStat(msg string)</a></dd>
			
				
				<dd><a href="#ProbContestSmall">func ProbContestSmall(u, v, φ float64) float64</a></dd>
			
				
				<dd><a href="#ProfCPU">func ProfCPU(dirout, filename string, silent bool) func()</a></dd>
			
				
				<dd><a href="#ProfMEM">func ProfMEM(dirout, filename string, silent bool) func()</a></dd>
			
				
				<dd><a href="#Scaling">func Scaling(s, x []float64, ds, tol float64, reverse, useinds bool) (xmin, xmax float64)</a></dd>
			
				
				<dd><a href="#SortQuadruples">func SortQuadruples(i []int, x, y, z []float64, by string) (I []int, X, Y, Z []float64, err error)</a></dd>
			
				
				<dd><a href="#Str2Dbl">func Str2Dbl(s []string) (v []float64)</a></dd>
			
				
				<dd><a href="#StrBoolMapSort">func StrBoolMapSort(m map[string]bool) (sorted_keys []string)</a></dd>
			
				
				<dd><a href="#StrBoolMapSortSplit">func StrBoolMapSortSplit(m map[string]bool) (sorted_keys []string, sorted_vals []bool)</a></dd>
			
				
				<dd><a href="#StrDblMapSort">func StrDblMapSort(m map[string]float64) (sorted_keys []string)</a></dd>
			
				
				<dd><a href="#StrDblMapSortSplit">func StrDblMapSortSplit(m map[string]float64) (sorted_keys []string, sorted_vals []float64)</a></dd>
			
				
				<dd><a href="#StrDblsMapAppend">func StrDblsMapAppend(m *map[string][]float64, key string, item float64)</a></dd>
			
				
				<dd><a href="#StrIndexSmall">func StrIndexSmall(a []string, val string) int</a></dd>
			
				
				<dd><a href="#StrIntMapSort">func StrIntMapSort(m map[string]int) (sorted_keys []string)</a></dd>
			
				
				<dd><a href="#StrIntMapSortSplit">func StrIntMapSortSplit(m map[string]int) (sorted_keys []string, sorted_vals []int)</a></dd>
			
				
				<dd><a href="#StrIntsMapAppend">func StrIntsMapAppend(m *map[string][]int, key string, item int)</a></dd>
			
				
				<dd><a href="#StrVals">func StrVals(n int, val string) (s []string)</a></dd>
			
				
				<dd><a href="#StrsAlloc">func StrsAlloc(m, n int) (mat [][]string)</a></dd>
			
			
				
				<dd><a href="#DblList">type DblList</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#DblList.Append">func (o *DblList) Append(rowidx int, value float64)</a></dd>
				
			
				
				<dd><a href="#DblSlist">type DblSlist</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#DblSlist.Append">func (o *DblSlist) Append(startRow bool, value float64)</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#DblSlist.Print">func (o DblSlist) Print(fmt string)</a></dd>
				
			
				
				<dd><a href="#Decoder">type Decoder</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#GetDecoder">func GetDecoder(r goio.Reader, enctype string) Decoder</a></dd>
				
				
			
				
				<dd><a href="#Encoder">type Encoder</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#GetEncoder">func GetEncoder(w goio.Writer, enctype string) Encoder</a></dd>
				
				
			
				
				<dd><a href="#Quadruple">type Quadruple</a></dd>
				
				
			
				
				<dd><a href="#Quadruples">type Quadruples</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#BuildQuadruples">func BuildQuadruples(i []int, x, y, z []float64) (q Quadruples)</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.I">func (o Quadruples) I() (i []int)</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.Len">func (o Quadruples) Len() int</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.String">func (o Quadruples) String() string</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.Swap">func (o Quadruples) Swap(i, j int)</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.X">func (o Quadruples) X() (x []float64)</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.Y">func (o Quadruples) Y() (y []float64)</a></dd>
				
					
					<dd>&nbsp; &nbsp; <a href="#Quadruples.Z">func (o Quadruples) Z() (z []float64)</a></dd>
				
			
				
				<dd><a href="#QuadruplesByI">type QuadruplesByI</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#QuadruplesByI.Less">func (o QuadruplesByI) Less(i, j int) bool</a></dd>
				
			
				
				<dd><a href="#QuadruplesByX">type QuadruplesByX</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#QuadruplesByX.Less">func (o QuadruplesByX) Less(i, j int) bool</a></dd>
				
			
				
				<dd><a href="#QuadruplesByY">type QuadruplesByY</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#QuadruplesByY.Less">func (o QuadruplesByY) Less(i, j int) bool</a></dd>
				
			
				
				<dd><a href="#QuadruplesByZ">type QuadruplesByZ</a></dd>
				
				
					
					<dd>&nbsp; &nbsp; <a href="#QuadruplesByZ.Less">func (o QuadruplesByZ) Less(i, j int) bool</a></dd>
				
			
			
			</dl>
			</div><!-- #manual-nav -->

		

		
			<h4>Package files</h4>
			<p>
			<span style="font-size:90%">
			
				<a href="/src/github.com/cpmech/gosl/utl/auxiliary.go">auxiliary.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/deepslices.go">deepslices.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/encoder.go">encoder.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/list.go">list.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/mapops.go">mapops.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/mylab.go">mylab.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/pareto.go">pareto.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/postprocess.go">postprocess.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/printing.go">printing.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/profiling.go">profiling.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/searching.go">searching.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/serialize.go">serialize.go</a>
			
				<a href="/src/github.com/cpmech/gosl/utl/sorting.go">sorting.go</a>
			
			</span>
			</p>
		
		</div><!-- .expanded -->
		</div><!-- #pkg-index -->

		<div id="pkg-callgraph" class="toggle" style="display: none">
		<div class="collapsed">
			<h2 class="toggleButton" title="Click to show Internal Call Graph section">Internal call graph ▹</h2>
		</div> <!-- .expanded -->
		<div class="expanded">
			<h2 class="toggleButton" title="Click to hide Internal Call Graph section">Internal call graph ▾</h2>
			<p>
			  In the call graph viewer below, each node
			  is a function belonging to this package
			  and its children are the functions it
			  calls&mdash;perhaps dynamically.
			</p>
			<p>
			  The root nodes are the entry points of the
			  package: functions that may be called from
			  outside the package.
			  There may be non-exported or anonymous
			  functions among them if they are called
			  dynamically from another package.
			</p>
			<p>
			  Click a node to visit that function's source code.
			  From there you can visit its callers by
			  clicking its declaring <code>func</code>
			  token.
			</p>
			<p>
			  Functions may be omitted if they were
			  determined to be unreachable in the
			  particular programs or tests that were
			  analyzed.
			</p>
			<!-- Zero means show all package entry points. -->
			<ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
		</div>
		</div> <!-- #pkg-callgraph -->

		
			<h2 id="pkg-constants">Constants</h2>
			
				<pre>const (
    <span id="KBSIZE">KBSIZE</span> = 1024.0
    <span id="MBSIZE">MBSIZE</span> = 1048576.0
    <span id="GBSIZE">GBSIZE</span> = 1073741824.0
)</pre>
				
			
				<pre>const <span id="PRINTDEEPZERO">PRINTDEEPZERO</span> = 1e-3</pre>
				
			
		
		
		
			
			
			<h2 id="BestSquare">func <a href="https://github.com/cpmech/gosl/blob/master/utl/auxiliary.go?s=243:285#L1">BestSquare</a></h2>
			<pre>func BestSquare(size <a href="/pkg/builtin/#int">int</a>) (nrow, ncol <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
BestSquare finds the best square for given size=Nrows * Ncolumns
</p>

			
			

		
			
			
			<h2 id="BoolAllFalse">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=9997:10034#L443">BoolAllFalse</a></h2>
			<pre>func BoolAllFalse(values []<a href="/pkg/builtin/#bool">bool</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
			<p>
BoolAllFalse returns true if all values are false
</p>

			
			

		
			
			
			<h2 id="BoolAllTrue">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=9828:9864#L433">BoolAllTrue</a></h2>
			<pre>func BoolAllTrue(values []<a href="/pkg/builtin/#bool">bool</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
			<p>
BoolAllTrue returns true if all values are true
</p>

			
			

		
			
			
			<h2 id="Cross3d">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=9322:9353#L406">Cross3d</a></h2>
			<pre>func Cross3d(w, u, v []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Cross3d computes the cross product of two 3D vectors u and w
</p>
<pre>w = u cross v
Note: w must be pre-allocated
</pre>

			
			

		
			
			
			<h2 id="CumSum">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=7930:7958#L352">CumSum</a></h2>
			<pre>func CumSum(cs, p []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
CumSum returns the cumulative sum of the elements in p
</p>
<pre>Input:
 p -- values
Output:
 cs -- cumulated sum; pre-allocated with len(cs) == len(p)
</pre>

			
			

		
			
			
			<h2 id="Dbl2Str">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=5038:5091#L222">Dbl2Str</a></h2>
			<pre>func Dbl2Str(v []<a href="/pkg/builtin/#float64">float64</a>, format <a href="/pkg/builtin/#string">string</a>) (s []<a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
Dbl2Str converts a slice of doubles (float64) to a slice of strings
</p>

			
			

		
			
			
			<h2 id="DblArgMinMax">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=9508:9555#L413">DblArgMinMax</a></h2>
			<pre>func DblArgMinMax(v []<a href="/pkg/builtin/#float64">float64</a>) (imin, imax <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
DblArgMinMax finds the indices of min and max arguments
</p>

			
			

		
			
			
			<h2 id="DblArrayToMat">func <a href="https://github.com/cpmech/gosl/blob/master/utl/serialize.go?s=539:596#L13">DblArrayToMat</a></h2>
			<pre>func DblArrayToMat(v []<a href="/pkg/builtin/#float64">float64</a>, m, n <a href="/pkg/builtin/#int">int</a>) (a [][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblArrayToMat converts a column-major array to a matrix
</p>

			
			

		
			
			
			<h2 id="DblCopy">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=4151:4193#L185">DblCopy</a></h2>
			<pre>func DblCopy(in []<a href="/pkg/builtin/#float64">float64</a>) (out []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblCopy gets a copy of slice of doubles
</p>

			
			

		
			
			
			<h2 id="DblDsort3">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=969:1001#L53">DblDsort3</a></h2>
			<pre>func DblDsort3(a, b, c *<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblDsort3 sorts 3 values in descending order
</p>

			
			

		
			
			
			<h2 id="DblGetSorted">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=1468:1518#L88">DblGetSorted</a></h2>
			<pre>func DblGetSorted(A []<a href="/pkg/builtin/#float64">float64</a>) (Asorted []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblGetSorted returns a sorted (increasing) copy of &#39;A&#39;
</p>

			
			

		
			
			
			<h2 id="DblMatToArray">func <a href="https://github.com/cpmech/gosl/blob/master/utl/serialize.go?s=272:319#L1">DblMatToArray</a></h2>
			<pre>func DblMatToArray(a [][]<a href="/pkg/builtin/#float64">float64</a>) (v []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblMatToArray converts a matrix into a column-major array
</p>

			
			

		
			
			
			<h2 id="DblMinMax">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=671:715#L21">DblMinMax</a></h2>
			<pre>func DblMinMax(v []<a href="/pkg/builtin/#float64">float64</a>) (mi, ma <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblMinMax returns the maximum and minimum elements in v
</p>
<pre>NOTE: this is not efficient and should be used for small slices only
</pre>

			
			

		
			
			
			<h2 id="DblOnes">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=3805:3840#L167">DblOnes</a></h2>
			<pre>func DblOnes(n <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblOnes generates a slice of double precision &#39;1s&#39;
</p>

			
			

		
			
			
			<h2 id="DblSort3">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=779:810#L40">DblSort3</a></h2>
			<pre>func DblSort3(a, b, c *<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblSort3 sorts 3 values in ascending order
</p>

			
			

		
			
			
			<h2 id="DblSort4">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=1160:1194#L66">DblSort4</a></h2>
			<pre>func DblSort4(a, b, c, d *<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblSort4 sort four values in ascending order
</p>

			
			

		
			
			
			<h2 id="DblSplit">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=5445:5482#L240">DblSplit</a></h2>
			<pre>func DblSplit(s <a href="/pkg/builtin/#string">string</a>) (r []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblSplit splits a string into floats
</p>

			
			

		
			
			
			<h2 id="DblSum">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=955:993#L36">DblSum</a></h2>
			<pre>func DblSum(v []<a href="/pkg/builtin/#float64">float64</a>) (sum <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblSum sums all items in v
</p>
<pre>NOTE: this is not efficient and should be used for small slices only
</pre>

			
			

		
			
			
			<h2 id="DblVals">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=3980:4026#L176">DblVals</a></h2>
			<pre>func DblVals(n <a href="/pkg/builtin/#int">int</a>, v <a href="/pkg/builtin/#float64">float64</a>) (res []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblVals generates a slice of double precision values
</p>

			
			

		
			
			
			<h2 id="DblsAlloc">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=1011:1053#L35">DblsAlloc</a></h2>
			<pre>func DblsAlloc(m, n <a href="/pkg/builtin/#int">int</a>) (mat [][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblsAlloc allocates a matrix of float64
</p>

			
			

		
			
			
			<h2 id="DblsGetColumn">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=8718:8772#L382">DblsGetColumn</a></h2>
			<pre>func DblsGetColumn(j <a href="/pkg/builtin/#int">int</a>, v [][]<a href="/pkg/builtin/#float64">float64</a>) (x []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DblsGetColumn returns the column of a matrix of reals numbers
</p>

			
			

		
			
			
			<h2 id="DblsParetoMin">func <a href="https://github.com/cpmech/gosl/blob/master/utl/pareto.go?s=350:416#L6">DblsParetoMin</a></h2>
			<pre>func DblsParetoMin(u, v []<a href="/pkg/builtin/#float64">float64</a>) (u_dominates, v_dominates <a href="/pkg/builtin/#bool">bool</a>)</pre>
			<p>
DblsParetoMin compares two vectors using Pareto&#39;s optimal criterion
</p>
<pre>Note: minimum dominates (is better)
</pre>

			
			

		
			
			
			<h2 id="DblsParetoMinProb">func <a href="https://github.com/cpmech/gosl/blob/master/utl/pareto.go?s=1409:1478#L37">DblsParetoMinProb</a></h2>
			<pre>func DblsParetoMinProb(u, v []<a href="/pkg/builtin/#float64">float64</a>, φ <a href="/pkg/builtin/#float64">float64</a>) (u_dominates <a href="/pkg/builtin/#bool">bool</a>)</pre>
			<p>
DblsParetoMinProb compares two vectors using Pareto&#39;s optimal criterion
φ ∃ [0,1] is a scaling factor that helps v win even if it&#39;s not smaller.
If φ==0, deterministic analysis is carried out. If φ==1, probabilistic analysis is carried out.
As φ → 1, v &#34;gets more help&#34;.
</p>
<pre>Note: (1) minimum dominates (is better)
      (2) v dominates if !u_dominates
</pre>

			
			

		
			
			
			<h2 id="Deep3Deserialize">func <a href="https://github.com/cpmech/gosl/blob/master/utl/serialize.go?s=1956:2032#L81">Deep3Deserialize</a></h2>
			<pre>func Deep3Deserialize(I, P []<a href="/pkg/builtin/#int">int</a>, S []<a href="/pkg/builtin/#float64">float64</a>, debug <a href="/pkg/builtin/#bool">bool</a>) (A [][][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep3Deserialize deserializes an array of array of array in column-compressed format
</p>
<pre>Example:
</pre>

			
			

		
			
			
			<h2 id="Deep3GetInfo">func <a href="https://github.com/cpmech/gosl/blob/master/utl/serialize.go?s=1359:1459#L57">Deep3GetInfo</a></h2>
			<pre>func Deep3GetInfo(I, P []<a href="/pkg/builtin/#int">int</a>, S []<a href="/pkg/builtin/#float64">float64</a>, verbose <a href="/pkg/builtin/#bool">bool</a>) (nitems, nrows, ncols_tot <a href="/pkg/builtin/#int">int</a>, ncols []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
Deep3GetInfo returns information of serialized array of array of array
</p>
<pre>Example:
</pre>

			
			

		
			
			
			<h2 id="Deep3Serialize">func <a href="https://github.com/cpmech/gosl/blob/master/utl/serialize.go?s=860:922#L28">Deep3Serialize</a></h2>
			<pre>func Deep3Serialize(A [][][]<a href="/pkg/builtin/#float64">float64</a>) (I, P []<a href="/pkg/builtin/#int">int</a>, S []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep3Serialize serializes an array of array of array in column-compressed format
</p>
<pre>Example:
</pre>

			
			

		
			
			
			<h2 id="Deep3alloc">func <a href="https://github.com/cpmech/gosl/blob/master/utl/deepslices.go?s=225:274#L1">Deep3alloc</a></h2>
			<pre>func Deep3alloc(n1, n2, n3 <a href="/pkg/builtin/#int">int</a>) (a [][][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep3alloc allocates a slice of slice of slice
</p>

			
			

		
			
			
			<h2 id="Deep3set">func <a href="https://github.com/cpmech/gosl/blob/master/utl/deepslices.go?s=863:904#L25">Deep3set</a></h2>
			<pre>func Deep3set(a [][][]<a href="/pkg/builtin/#float64">float64</a>, v <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep3set sets deep slice of slice of slice with v values
</p>

			
			

		
			
			
			<h2 id="Deep4alloc">func <a href="https://github.com/cpmech/gosl/blob/master/utl/deepslices.go?s=502:557#L10">Deep4alloc</a></h2>
			<pre>func Deep4alloc(n1, n2, n3, n4 <a href="/pkg/builtin/#int">int</a>) (a [][][][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep4alloc allocates a slice of slice of slice of slice
</p>

			
			

		
			
			
			<h2 id="Deep4set">func <a href="https://github.com/cpmech/gosl/blob/master/utl/deepslices.go?s=1115:1158#L36">Deep4set</a></h2>
			<pre>func Deep4set(a [][][][]<a href="/pkg/builtin/#float64">float64</a>, v <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Deep4set sets deep slice of slice of slice of slice with v values
</p>

			
			

		
			
			
			<h2 id="Digits">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=5637:5689#L250">Digits</a></h2>
			<pre>func Digits(maxint <a href="/pkg/builtin/#int">int</a>) (ndigits <a href="/pkg/builtin/#int">int</a>, format <a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
Digits returns the nubmer of digits
</p>

			
			

		
			
			
			<h2 id="DoProf">func <a href="https://github.com/cpmech/gosl/blob/master/utl/profiling.go?s=2798:2841#L82">DoProf</a></h2>
			<pre>func DoProf(silent <a href="/pkg/builtin/#bool">bool</a>, option <a href="/pkg/builtin/#int">int</a>) func()</pre>
			<p>
DoProf runs either CPU profiling or MEM profiling
</p>
<pre>Input:
  silent -- show message
  option -- 1=CPU profiling, 2=memory profiling
Output:
  1) returns a &#34;stop()&#34; function to be called before shutting down
  2) output files are saved to &#34;/tmp/gosl/cpu.pprof&#34;; or
                               &#34;/tmp/gosl/mem.pprof&#34;
  3) run analysis with (e.g.):
       go tool pprof binary /tmp/gosl/mem.pprof
</pre>

			
			

		
			
			
			<h2 id="Dot3d">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=9120:9158#L399">Dot3d</a></h2>
			<pre>func Dot3d(u, v []<a href="/pkg/builtin/#float64">float64</a>) (s <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Dot3d returns the dot product between two 3D vectors
</p>

			
			

		
			
			
			<h2 id="DurSum">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=1160:1208#L45">DurSum</a></h2>
			<pre>func DurSum(v []<a href="/pkg/time/">time</a>.<a href="/pkg/time/#Duration">Duration</a>) (seconds <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
DurSum sums all seconds in v
</p>
<pre>NOTE: this is not efficient and should be used for small slices only
</pre>

			
			

		
			
			
			<h2 id="Expon">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=5815:5852#L257">Expon</a></h2>
			<pre>func Expon(val <a href="/pkg/builtin/#float64">float64</a>) (ndigits <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
Expon returns the exponent
</p>

			
			

		
			
			
			<h2 id="FlipCoin">func <a href="https://github.com/cpmech/gosl/blob/master/utl/pareto.go?s=2344:2373#L68">FlipCoin</a></h2>
			<pre>func FlipCoin(p <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
			<p>
FlipCoin generates a Bernoulli variable; throw a coin with probability p
</p>

			
			

		
			
			
			<h2 id="GetITout">func <a href="https://github.com/cpmech/gosl/blob/master/utl/postprocess.go?s=643:739#L11">GetITout</a></h2>
			<pre>func GetITout(all_output_times, time_stations_out []<a href="/pkg/builtin/#float64">float64</a>, tol <a href="/pkg/builtin/#float64">float64</a>) (I []<a href="/pkg/builtin/#int">int</a>, T []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
GetITout returns indices and output times
</p>
<pre>Input:
  all_output_times  -- array with all output times. ex: [0,0.1,0.2,0.22,0.3,0.4]
  time_stations_out -- time stations for output: ex: [0,0.2,0.4]
  tol               -- tolerance to compare times
Output:
  iout -- indices of times in all_output_times
  tout -- times corresponding to iout
Notes:
  use -1 in all_output_times to enforce output of last timestep
</pre>

			
			

		
			
			
			<h2 id="GtPenalty">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=8224:8270#L365">GtPenalty</a></h2>
			<pre>func GtPenalty(x, b, penaltyM <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#float64">float64</a></pre>
			<p>
GtPenalty implements a &#39;greater than&#39; penalty function where
x must be greater than b; otherwise the error is magnified
</p>

			
			

		
			
			
			<h2 id="GtePenalty">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=8544:8591#L374">GtePenalty</a></h2>
			<pre>func GtePenalty(x, b, penaltyM <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#float64">float64</a></pre>
			<p>
GtePenalty implements a &#39;greater than or equal&#39; penalty function where
x must be greater than b or equal to be; otherwise the error is magnified
</p>

			
			

		
			
			
			<h2 id="Imax">func <a href="https://github.com/cpmech/gosl/blob/master/utl/auxiliary.go?s=760:783#L30">Imax</a></h2>
			<pre>func Imax(a, b <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#int">int</a></pre>
			<p>
Imin returns the maximum between two integers
</p>

			
			

		
			
			
			<h2 id="Imin">func <a href="https://github.com/cpmech/gosl/blob/master/utl/auxiliary.go?s=646:669#L22">Imin</a></h2>
			<pre>func Imin(a, b <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#int">int</a></pre>
			<p>
Imin returns the minimum between two integers
</p>

			
			

		
			
			
			<h2 id="IntAddScalar">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=2702:2747#L115">IntAddScalar</a></h2>
			<pre>func IntAddScalar(a []<a href="/pkg/builtin/#int">int</a>, s <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntAddScalar adds a scalar to all values in a slice of integers
</p>

			
			

		
			
			
			<h2 id="IntBoolMapSort">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=6595:6650#L319">IntBoolMapSort</a></h2>
			<pre>func IntBoolMapSort(m map[<a href="/pkg/builtin/#int">int</a>]<a href="/pkg/builtin/#bool">bool</a>) (sorted_keys []<a href="/pkg/builtin/#int">int</a>)</pre>
			
			
			

		
			
			
			<h2 id="IntFill">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=507:537#L10">IntFill</a></h2>
			<pre>func IntFill(s []<a href="/pkg/builtin/#int">int</a>, val <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntFill fills a slice of integers
</p>

			
			

		
			
			
			<h2 id="IntFilter">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=3186:3245#L108">IntFilter</a></h2>
			<pre>func IntFilter(a []<a href="/pkg/builtin/#int">int</a>, out func(idx <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#bool">bool</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntFilter filters out components in slice
</p>
<pre>NOTE: this function is not efficient and should be used with small slices only
</pre>

			
			

		
			
			
			<h2 id="IntIndexSmall">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=1752:1792#L65">IntIndexSmall</a></h2>
			<pre>func IntIndexSmall(a []<a href="/pkg/builtin/#int">int</a>, val <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#int">int</a></pre>
			<p>
IntIndexSmall finds the index of an item in a slice of ints
</p>
<pre>NOTE: this function is not efficient and should be used with small slices only; say smaller than 20
</pre>

			
			

		
			
			
			<h2 id="IntIndexSorted">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=2534:2616#L89">IntIndexSorted</a></h2>
			<pre>func IntIndexSorted(a []<a href="/pkg/builtin/#int">int</a>, val <a href="/pkg/builtin/#int">int</a>, aSortedIn []<a href="/pkg/builtin/#int">int</a>) (idx <a href="/pkg/builtin/#int">int</a>, aSortedOut []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntIndexSorted finds the index of an item in a slice of ints by means of
searching a sorted list (given or computed here)
</p>
<pre>Input:
 a         -- the list
 val       -- value to be searched for
 aSortedIn -- an existing sorted &#39;a&#39; list or &lt;nil&gt;
Output:
 idx        -- position in &#39;a&#39; where val is located if found; otherwise returns -1
 aSortedOut -- sorted list if the input aSortedIn is &lt;nil&gt;
Note: If you were to sort the array with MergeSort or any other O(nlogn) algorithm then
      the complexity would be O(nlogn).
      O(logn) &lt; O(n) &lt; O(nlogn)

TODO: this function is finished yet
</pre>

			
			

		
			
			
			<h2 id="IntIntsMapAppend">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mapops.go?s=309:367#L1">IntIntsMapAppend</a></h2>
			<pre>func IntIntsMapAppend(m *map[<a href="/pkg/builtin/#int">int</a>][]<a href="/pkg/builtin/#int">int</a>, key <a href="/pkg/builtin/#int">int</a>, item <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntIntsMapAppend appends a new item to a map of slice.
</p>
<pre>Note: this function creates a new slice in the map if key is not found.
</pre>

			
			

		
			
			
			<h2 id="IntMinMax">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=366:402#L6">IntMinMax</a></h2>
			<pre>func IntMinMax(v []<a href="/pkg/builtin/#int">int</a>) (mi, ma <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntMinMax returns the maximum and minimum elements in v
</p>
<pre>NOTE: this is not efficient and should be used for small slices only
</pre>

			
			

		
			
			
			<h2 id="IntNegOut">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=3486:3521#L120">IntNegOut</a></h2>
			<pre>func IntNegOut(a []<a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntNegOut filters out negative components in slice
</p>
<pre>NOTE: this function is not efficient and should be used with small slices only
</pre>

			
			

		
			
			
			<h2 id="IntPy">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=3581:3613#L154">IntPy</a></h2>
			<pre>func IntPy(a []<a href="/pkg/builtin/#int">int</a>) (res <a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
IntPy returns a Python string representing a slice of integers
</p>

			
			

		
			
			
			<h2 id="IntRange">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=1827:1859#L74">IntRange</a></h2>
			<pre>func IntRange(n <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntRange generates a slice of integers from 0 to n-1
</p>

			
			

		
			
			
			<h2 id="IntRange2">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=2037:2074#L86">IntRange2</a></h2>
			<pre>func IntRange2(start, stop <a href="/pkg/builtin/#int">int</a>) []<a href="/pkg/builtin/#int">int</a></pre>
			<p>
IntRange2 generates slice of integers from start to stop (but not stop)
</p>

			
			

		
			
			
			<h2 id="IntRange3">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=2209:2258#L91">IntRange3</a></h2>
			<pre>func IntRange3(start, stop, step <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntRange3 generates a slice of integers from start to stop (but not stop), afer each &#39;step&#39;
</p>

			
			

		
			
			
			<h2 id="IntSort3">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=301:328#L5">IntSort3</a></h2>
			<pre>func IntSort3(a, b, c *<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntSort3 sorts 3 values in ascending order
</p>

			
			

		
			
			
			<h2 id="IntSort4">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=487:517#L18">IntSort4</a></h2>
			<pre>func IntSort4(a, b, c, d *<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntSort4 sort four values in ascending order
</p>

			
			

		
			
			
			<h2 id="IntUnique">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=2901:2944#L124">IntUnique</a></h2>
			<pre>func IntUnique(slices ...[]<a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntUnique returns a unique and sorted slice of integers
</p>

			
			

		
			
			
			<h2 id="IntVals">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=661:699#L17">IntVals</a></h2>
			<pre>func IntVals(n <a href="/pkg/builtin/#int">int</a>, val <a href="/pkg/builtin/#int">int</a>) (s []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntVals allocates a slice of integers with size==n, filled with val
</p>

			
			

		
			
			
			<h2 id="IntsAlloc">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=1381:1419#L53">IntsAlloc</a></h2>
			<pre>func IntsAlloc(m, n <a href="/pkg/builtin/#int">int</a>) (mat [][]<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntsAlloc allocates a matrix of integers
</p>

			
			

		
			
			
			<h2 id="IntsClone">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=1567:1604#L62">IntsClone</a></h2>
			<pre>func IntsClone(a [][]<a href="/pkg/builtin/#int">int</a>) (b [][]<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
IntsClone allocates and clones a matrix of integers
</p>

			
			

		
			
			
			<h2 id="L2norm">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=8923:8965#L391">L2norm</a></h2>
			<pre>func L2norm(p, q []<a href="/pkg/builtin/#float64">float64</a>) (dist <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
L2norm returns the Euclidean distance between p and q
</p>

			
			

		
			
			
			<h2 id="LinSpace">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=4330:4389#L192">LinSpace</a></h2>
			<pre>func LinSpace(start, stop <a href="/pkg/builtin/#float64">float64</a>, num <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
LinSpace returns evenly spaced numbers over a specified closed interval.
</p>

			
			

		
			
			
			<h2 id="LinSpaceOpen">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=4718:4781#L209">LinSpaceOpen</a></h2>
			<pre>func LinSpaceOpen(start, stop <a href="/pkg/builtin/#float64">float64</a>, num <a href="/pkg/builtin/#int">int</a>) (res []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
LinSpaceOpen returns evenly spaced numbers over a specified open interval.
</p>

			
			

		
			
			
			<h2 id="Max">func <a href="https://github.com/cpmech/gosl/blob/master/utl/auxiliary.go?s=1015:1045#L46">Max</a></h2>
			<pre>func Max(a, b <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#float64">float64</a></pre>
			<p>
Max returns the maximum between two float point numbers
</p>

			
			

		
			
			
			<h2 id="MeshGrid2D">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=6023:6101#L268">MeshGrid2D</a></h2>
			<pre>func MeshGrid2D(xmin, xmax, ymin, ymax <a href="/pkg/builtin/#float64">float64</a>, nx, ny <a href="/pkg/builtin/#int">int</a>) (x, y [][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
MeshGrid2D creates a grid with x-y coordinates
</p>
<pre>x -- [ny][nx]
y -- [ny][nx]
</pre>

			
			

		
			
			
			<h2 id="Min">func <a href="https://github.com/cpmech/gosl/blob/master/utl/auxiliary.go?s=884:914#L38">Min</a></h2>
			<pre>func Min(a, b <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#float64">float64</a></pre>
			<p>
Min returns the minimum between two float point numbers
</p>

			
			

		
			
			
			<h2 id="ParetoFront">func <a href="https://github.com/cpmech/gosl/blob/master/utl/pareto.go?s=2704:2751#L87">ParetoFront</a></h2>
			<pre>func ParetoFront(Ovs [][]<a href="/pkg/builtin/#float64">float64</a>) (front []<a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
ParetoFront computes the Pareto optimal front
</p>
<pre>Input:
 Ovs -- [nsamples][ndim] objective values
Output:
 front -- indices of pareto front
Note: this function is slow for large sets
</pre>

			
			

		
			
			
			<h2 id="PrintDeep3">func <a href="https://github.com/cpmech/gosl/blob/master/utl/printing.go?s=308:353#L7">PrintDeep3</a></h2>
			<pre>func PrintDeep3(name <a href="/pkg/builtin/#string">string</a>, A [][][]<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
PrintDeep3 prints an array of array of array
</p>

			
			

		
			
			
			<h2 id="PrintDeep4">func <a href="https://github.com/cpmech/gosl/blob/master/utl/printing.go?s=493:555#L16">PrintDeep4</a></h2>
			<pre>func PrintDeep4(name <a href="/pkg/builtin/#string">string</a>, A [][][][]<a href="/pkg/builtin/#float64">float64</a>, format <a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
PrintDeep4 prints an array of array of array
</p>

			
			

		
			
			
			<h2 id="PrintMemStat">func <a href="https://github.com/cpmech/gosl/blob/master/utl/profiling.go?s=410:439#L14">PrintMemStat</a></h2>
			<pre>func PrintMemStat(msg <a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
PrintMemStat prints memory statistics
</p>

			
			

		
			
			
			<h2 id="ProbContestSmall">func <a href="https://github.com/cpmech/gosl/blob/master/utl/pareto.go?s=2056:2103#L55">ProbContestSmall</a></h2>
			<pre>func ProbContestSmall(u, v, φ <a href="/pkg/builtin/#float64">float64</a>) <a href="/pkg/builtin/#float64">float64</a></pre>
			<p>
ProbContestSmall computes the probability for a contest between u and v where u wins if it&#39;s
the smaller value. φ ∃ [0,1] is a scaling factor that helps v win even if it&#39;s not smaller.
If φ==0, deterministic analysis is carried out. If φ==1, probabilistic analysis is carried out.
As φ → 1, v &#34;gets more help&#34;.
</p>

			
			

		
			
			
			<h2 id="ProfCPU">func <a href="https://github.com/cpmech/gosl/blob/master/utl/profiling.go?s=1282:1339#L29">ProfCPU</a></h2>
			<pre>func ProfCPU(dirout, filename <a href="/pkg/builtin/#string">string</a>, silent <a href="/pkg/builtin/#bool">bool</a>) func()</pre>
			<p>
ProfCPU activates CPU profiling
</p>
<pre>Note: returns a &#34;stop()&#34; function to be called before shutting down
</pre>

			
			

		
			
			
			<h2 id="ProfMEM">func <a href="https://github.com/cpmech/gosl/blob/master/utl/profiling.go?s=1890:1947#L52">ProfMEM</a></h2>
			<pre>func ProfMEM(dirout, filename <a href="/pkg/builtin/#string">string</a>, silent <a href="/pkg/builtin/#bool">bool</a>) func()</pre>
			<p>
ProfMEM activates memory profiling
</p>
<pre>Note: returns a &#34;stop()&#34; function to be called before shutting down
</pre>

			
			

		
			
			
			<h2 id="Scaling">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=7018:7107#L300">Scaling</a></h2>
			<pre>func Scaling(s, x []<a href="/pkg/builtin/#float64">float64</a>, ds, tol <a href="/pkg/builtin/#float64">float64</a>, reverse, useinds <a href="/pkg/builtin/#bool">bool</a>) (xmin, xmax <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Scaling computes a scaled version of the input slice with results in [0.0, 1.0]
</p>
<pre>Input:
 x       -- values
 ds      -- δs value to be added to all &#39;s&#39; values
 tol     -- tolerance for capturing xmax ≅ xmin
 reverse -- compute reverse series;
            i.e. &#39;s&#39; decreases from 1 to 0 while x goes from xmin to xmax
 useinds -- if (xmax-xmin)&lt;tol, use indices to generate the &#39;s&#39; slice;
            otherwise, &#39;s&#39; will be filled with δs + zeros
Ouptut:
 s          -- scaled series; pre--allocated with len(s) == len(x)
 xmin, xmax -- min(x) and max(x)
</pre>

			
			

		
			
			
			<h2 id="SortQuadruples">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=4205:4303#L208">SortQuadruples</a></h2>
			<pre>func SortQuadruples(i []<a href="/pkg/builtin/#int">int</a>, x, y, z []<a href="/pkg/builtin/#float64">float64</a>, by <a href="/pkg/builtin/#string">string</a>) (I []<a href="/pkg/builtin/#int">int</a>, X, Y, Z []<a href="/pkg/builtin/#float64">float64</a>, err <a href="/pkg/builtin/#error">error</a>)</pre>
			<p>
SortQuadruples sorts i, x, y, and z by &#34;i&#34;, &#34;x&#34;, &#34;y&#34;, or &#34;z&#34;
</p>
<pre>Note: either i, x, y, or z can be nil; i.e. at least one of them must be non nil
</pre>

			
			

		
			
			
			<h2 id="Str2Dbl">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=5267:5305#L231">Str2Dbl</a></h2>
			<pre>func Str2Dbl(s []<a href="/pkg/builtin/#string">string</a>) (v []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
Str2Dbl converts a slice of strings to a slice of doubles (float64)
</p>

			
			

		
			
			
			<h2 id="StrBoolMapSort">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=5294:5355#L261">StrBoolMapSort</a></h2>
			<pre>func StrBoolMapSort(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#bool">bool</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrBoolMapSortSplit">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=6163:6249#L302">StrBoolMapSortSplit</a></h2>
			<pre>func StrBoolMapSortSplit(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#bool">bool</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>, sorted_vals []<a href="/pkg/builtin/#bool">bool</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrDblMapSort">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=5087:5150#L250">StrDblMapSort</a></h2>
			<pre>func StrDblMapSort(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#float64">float64</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrDblMapSortSplit">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=5825:5916#L287">StrDblMapSortSplit</a></h2>
			<pre>func StrDblMapSortSplit(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#float64">float64</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>, sorted_vals []<a href="/pkg/builtin/#float64">float64</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrDblsMapAppend">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mapops.go?s=955:1027#L21">StrDblsMapAppend</a></h2>
			<pre>func StrDblsMapAppend(m *map[<a href="/pkg/builtin/#string">string</a>][]<a href="/pkg/builtin/#float64">float64</a>, key <a href="/pkg/builtin/#string">string</a>, item <a href="/pkg/builtin/#float64">float64</a>)</pre>
			<p>
StrDblsMapAppend appends a new item to a map of slice.
</p>
<pre>Note: this function creates a new slice in the map if key is not found.
</pre>

			
			

		
			
			
			<h2 id="StrIndexSmall">func <a href="https://github.com/cpmech/gosl/blob/master/utl/searching.go?s=1443:1489#L54">StrIndexSmall</a></h2>
			<pre>func StrIndexSmall(a []<a href="/pkg/builtin/#string">string</a>, val <a href="/pkg/builtin/#string">string</a>) <a href="/pkg/builtin/#int">int</a></pre>
			<p>
StrIndexSmall finds the index of an item in a slice of strings
</p>
<pre>NOTE: this function is not efficient and should be used with small slices only; say smaller than 20
</pre>

			
			

		
			
			
			<h2 id="StrIntMapSort">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=4884:4943#L239">StrIntMapSort</a></h2>
			<pre>func StrIntMapSort(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#int">int</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrIntMapSortSplit">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=5499:5582#L272">StrIntMapSortSplit</a></h2>
			<pre>func StrIntMapSortSplit(m map[<a href="/pkg/builtin/#string">string</a>]<a href="/pkg/builtin/#int">int</a>) (sorted_keys []<a href="/pkg/builtin/#string">string</a>, sorted_vals []<a href="/pkg/builtin/#int">int</a>)</pre>
			
			
			

		
			
			
			<h2 id="StrIntsMapAppend">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mapops.go?s=629:693#L10">StrIntsMapAppend</a></h2>
			<pre>func StrIntsMapAppend(m *map[<a href="/pkg/builtin/#string">string</a>][]<a href="/pkg/builtin/#int">int</a>, key <a href="/pkg/builtin/#string">string</a>, item <a href="/pkg/builtin/#int">int</a>)</pre>
			<p>
StrIntsMapAppend appends a new item to a map of slice.
</p>
<pre>Note: this function creates a new slice in the map if key is not found.
</pre>

			
			

		
			
			
			<h2 id="StrVals">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=845:889#L26">StrVals</a></h2>
			<pre>func StrVals(n <a href="/pkg/builtin/#int">int</a>, val <a href="/pkg/builtin/#string">string</a>) (s []<a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
StrVals allocates a slice of strings with size==n, filled with val
</p>

			
			

		
			
			
			<h2 id="StrsAlloc">func <a href="https://github.com/cpmech/gosl/blob/master/utl/mylab.go?s=1197:1238#L44">StrsAlloc</a></h2>
			<pre>func StrsAlloc(m, n <a href="/pkg/builtin/#int">int</a>) (mat [][]<a href="/pkg/builtin/#string">string</a>)</pre>
			<p>
StrsAlloc allocates a matrix of strings
</p>

			
			

		
		
			
			
			<h2 id="DblList">type <a href="https://github.com/cpmech/gosl/blob/master/utl/list.go?s=452:503#L7">DblList</a></h2>
			<pre>type DblList struct {
    Vals [][]<a href="/pkg/builtin/#float64">float64</a> <span class="comment">// values</span>
}</pre>
			<p>
DblList implements a tabular list with variable number of columns
</p>
<pre>Example:
  Vals = [][]float64{
           {0.0},
           {1.0, 1.1, 1.2, 1.3},
           {2.0, 2.1},
           {3.0, 3.1, 3.2},
         }
</pre>


			

			

			
			
			

			

			
				
				<h3 id="DblList.Append">func (*DblList) <a href="https://github.com/cpmech/gosl/blob/master/utl/list.go?s=540:591#L12">Append</a></h3>
				<pre>func (o *<a href="#DblList">DblList</a>) Append(rowidx <a href="/pkg/builtin/#int">int</a>, value <a href="/pkg/builtin/#float64">float64</a>)</pre>
				<p>
Append appends items to DblList
</p>

				
				
				
			
		
			
			
			<h2 id="DblSlist">type <a href="https://github.com/cpmech/gosl/blob/master/utl/list.go?s=1275:1353#L40">DblSlist</a></h2>
			<pre>type DblSlist struct {
    Vals []<a href="/pkg/builtin/#float64">float64</a> <span class="comment">// values</span>
    Ptrs []<a href="/pkg/builtin/#int">int</a>     <span class="comment">// pointers</span>
}</pre>
			<p>
DblSlist implements a tabular list with variable number of columns
using a serial representation
</p>
<pre>Example:
    0.0
    1.0  1.1  1.2  1.3
    2.0  2.1
    3.0  3.1  3.2
becomes:
           (0)   (1)    2    3    4   (5)    6   (7)    8    9   (10)
    Vals = 0.0 | 1.0  1.1  1.2  1.3 | 2.0  2.1 | 3.0  3.1  3.2 |
    Ptrs = 0 1 5 7 10
Notes:
    len(Ptrs) = nrows + 1
    Ptrs[len(Ptrs)-1] = len(Vals)
</pre>


			

			

			
			
			

			

			
				
				<h3 id="DblSlist.Append">func (*DblSlist) <a href="https://github.com/cpmech/gosl/blob/master/utl/list.go?s=1390:1445#L46">Append</a></h3>
				<pre>func (o *<a href="#DblSlist">DblSlist</a>) Append(startRow <a href="/pkg/builtin/#bool">bool</a>, value <a href="/pkg/builtin/#float64">float64</a>)</pre>
				<p>
Append appends item to DblSlist
</p>

				
				
				
			
				
				<h3 id="DblSlist.Print">func (DblSlist) <a href="https://github.com/cpmech/gosl/blob/master/utl/list.go?s=1699:1734#L60">Print</a></h3>
				<pre>func (o <a href="#DblSlist">DblSlist</a>) Print(fmt <a href="/pkg/builtin/#string">string</a>)</pre>
				<p>
Print prints the souble-serial-list
</p>

				
				
				
			
		
			
			
			<h2 id="Decoder">type <a href="https://github.com/cpmech/gosl/blob/master/utl/encoder.go?s=380:435#L9">Decoder</a></h2>
			<pre>type Decoder interface {
    Decode(e interface{}) <a href="/pkg/builtin/#error">error</a>
}</pre>
			<p>
Decoder defines decoders; e.g. gob or json
</p>


			

			

			
			
			

			
				
				<h3 id="GetDecoder">func <a href="https://github.com/cpmech/gosl/blob/master/utl/encoder.go?s=650:704#L22">GetDecoder</a></h3>
				<pre>func GetDecoder(r <a href="/pkg/io/">goio</a>.<a href="/pkg/io/#Reader">Reader</a>, enctype <a href="/pkg/builtin/#string">string</a>) <a href="#Decoder">Decoder</a></pre>
				<p>
GetDecoder returns a new decoder
</p>

				
				
			

			
		
			
			
			<h2 id="Encoder">type <a href="https://github.com/cpmech/gosl/blob/master/utl/encoder.go?s=277:332#L4">Encoder</a></h2>
			<pre>type Encoder interface {
    Encode(e interface{}) <a href="/pkg/builtin/#error">error</a>
}</pre>
			<p>
Encoder defines encoders; e.g. gob or json
</p>


			

			

			
			
			

			
				
				<h3 id="GetEncoder">func <a href="https://github.com/cpmech/gosl/blob/master/utl/encoder.go?s=473:527#L14">GetEncoder</a></h3>
				<pre>func GetEncoder(w <a href="/pkg/io/">goio</a>.<a href="/pkg/io/#Writer">Writer</a>, enctype <a href="/pkg/builtin/#string">string</a>) <a href="#Encoder">Encoder</a></pre>
				<p>
GetEncoder returns a new encoder
</p>

				
				
			

			
		
			
			
			<h2 id="Quadruple">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=1672:1737#L96">Quadruple</a></h2>
			<pre>type Quadruple struct {
    I <a href="/pkg/builtin/#int">int</a>
    X <a href="/pkg/builtin/#float64">float64</a>
    Y <a href="/pkg/builtin/#float64">float64</a>
    Z <a href="/pkg/builtin/#float64">float64</a>
}</pre>
			<p>
Quadruple helps to sort a quadruple of 1 int and 3 float64s
</p>


			

			

			
			
			

			

			
		
			
			
			<h2 id="Quadruples">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=1778:1806#L104">Quadruples</a></h2>
			<pre>type Quadruples []*<a href="#Quadruple">Quadruple</a></pre>
			<p>
Quadruples helps to sort quadruples
</p>


			

			

			
			
			

			
				
				<h3 id="BuildQuadruples">func <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=1935:1998#L108">BuildQuadruples</a></h3>
				<pre>func BuildQuadruples(i []<a href="/pkg/builtin/#int">int</a>, x, y, z []<a href="/pkg/builtin/#float64">float64</a>) (q <a href="#Quadruples">Quadruples</a>)</pre>
				<p>
Init initialise Quadruples with i, x, y, and z
</p>
<pre>Note: i, x, y, or z can be nil; but at least one of them must be non nil
</pre>

				
				
			

			
				
				<h3 id="Quadruples.I">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=2421:2454#L136">I</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) I() (i []<a href="/pkg/builtin/#int">int</a>)</pre>
				<p>
I returns the &#39;i&#39; in quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.Len">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3078:3107#L172">Len</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) Len() <a href="/pkg/builtin/#int">int</a></pre>
				<p>
Len returns the length of Quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.String">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3278:3313#L178">String</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) String() <a href="/pkg/builtin/#string">string</a></pre>
				<p>
String returns the string representation of Quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.Swap">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3156:3190#L175">Swap</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) Swap(i, j <a href="/pkg/builtin/#int">int</a>)</pre>
				<p>
Swap swaps two quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.X">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=2578:2615#L145">X</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) X() (x []<a href="/pkg/builtin/#float64">float64</a>)</pre>
				<p>
X returns the &#39;x&#39; in quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.Y">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=2743:2780#L154">Y</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) Y() (y []<a href="/pkg/builtin/#float64">float64</a>)</pre>
				<p>
Y returns the &#39;y&#39; in quadruples
</p>

				
				
				
			
				
				<h3 id="Quadruples.Z">func (Quadruples) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=2908:2945#L163">Z</a></h3>
				<pre>func (o <a href="#Quadruples">Quadruples</a>) Z() (z []<a href="/pkg/builtin/#float64">float64</a>)</pre>
				<p>
Z returns the &#39;z&#39; in quadruples
</p>

				
				
				
			
		
			
			
			<h2 id="QuadruplesByI">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3448:3487#L187">QuadruplesByI</a></h2>
			<pre>type QuadruplesByI struct{ <a href="#Quadruples">Quadruples</a> }</pre>
			<p>
Sort Quadruples by I
</p>


			

			

			
			
			

			

			
				
				<h3 id="QuadruplesByI.Less">func (QuadruplesByI) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3489:3531#L189">Less</a></h3>
				<pre>func (o <a href="#QuadruplesByI">QuadruplesByI</a>) Less(i, j <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
				
				
				
				
			
		
			
			
			<h2 id="QuadruplesByX">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3606:3645#L192">QuadruplesByX</a></h2>
			<pre>type QuadruplesByX struct{ <a href="#Quadruples">Quadruples</a> }</pre>
			<p>
Sort Quadruples by X
</p>


			

			

			
			
			

			

			
				
				<h3 id="QuadruplesByX.Less">func (QuadruplesByX) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3647:3689#L194">Less</a></h3>
				<pre>func (o <a href="#QuadruplesByX">QuadruplesByX</a>) Less(i, j <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
				
				
				
				
			
		
			
			
			<h2 id="QuadruplesByY">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3764:3803#L197">QuadruplesByY</a></h2>
			<pre>type QuadruplesByY struct{ <a href="#Quadruples">Quadruples</a> }</pre>
			<p>
Sort Quadruples by Y
</p>


			

			

			
			
			

			

			
				
				<h3 id="QuadruplesByY.Less">func (QuadruplesByY) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3805:3847#L199">Less</a></h3>
				<pre>func (o <a href="#QuadruplesByY">QuadruplesByY</a>) Less(i, j <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
				
				
				
				
			
		
			
			
			<h2 id="QuadruplesByZ">type <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3922:3961#L202">QuadruplesByZ</a></h2>
			<pre>type QuadruplesByZ struct{ <a href="#Quadruples">Quadruples</a> }</pre>
			<p>
Sort Quadruples by Z
</p>


			

			

			
			
			

			

			
				
				<h3 id="QuadruplesByZ.Less">func (QuadruplesByZ) <a href="https://github.com/cpmech/gosl/blob/master/utl/sorting.go?s=3963:4005#L204">Less</a></h3>
				<pre>func (o <a href="#QuadruplesByZ">QuadruplesByZ</a>) Less(i, j <a href="/pkg/builtin/#int">int</a>) <a href="/pkg/builtin/#bool">bool</a></pre>
				
				
				
				
			
		
	

	





	
	
		<h2 id="pkg-subdirectories">Subdirectories</h2>
	
	


	<div class="pkg-dir">
		<table>
			<tr>
				<th class="pkg-name">Name</th>
				<th class="pkg-synopsis">Synopsis</th>
			</tr>

			
			<tr>
				<td colspan="2"><a href="..">..</a></td>
			</tr>
			

			
				
					<tr>
						<td class="pkg-name" style="padding-left: 0px;">
							<a href="data/">data</a>
						</td>
						<td class="pkg-synopsis">
							
						</td>
					</tr>
				
			
		</table>
	</div>


	


<div id="footer">
<br /><br />
<hr>
<pre class="copyright">
Copyright (c) 2016, The Gosl Authors. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of Gosl nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

</pre><!-- copyright -->
</div><!-- footer -->

</div><!-- container -->
</div><!-- page -->
</body>
</html>
